/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package model.gestion_mouvement;

import java.util.ArrayList;
import java.util.Stack;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author ANNAS
 */
public class MouvementCalculateurPion extends MouvementCalculateur {

        Stack<ICase> mStack = new Stack<ICase>();             // Contient le chemin
        Stack<ICase> mTabPath[];            // Contiendra tous les chemins 
        int mNbPath;                    // Nombre de chemins possibles
        boolean mHasEat;                 // True si le pion a déjà mangé 
        
        // Structure
        class sCase {
           ICase sCurrentCase;      //ICase actuelle
            boolean sCheckNE = true;   
            IPiece sPiece;
        }
        sCase mBeginCase; 
        ArrayList<sCase> mListCurrentCase = new ArrayList<sCase>();  // Pour revenir sur les cases jouées et voir les autres chemins possibles
        int mNbCurrentCase = 0;
        
        IPiece mPiece;
    public MouvementCalculateurPion(){};
    public MouvementCalculateurPion(IPiece pPiece) { mPiece = pPiece; };
    
    protected void calculMouvement() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
  
    public ArrayList<ICase> getPlusSureChemin()
    {
        return new ArrayList<ICase>(); 
    }
    
    private void checkNE(sCase pCurrentCase)
    {         
        mHasEat = false;
        while(pCurrentCase.sCheckNE == true)
        {
            pCurrentCase.sCheckNE = false;
           ICase vNextCase =null;
            
            if(vNextCase.hasPiece() == false)    // Deplacement simple
            {
                System.out.println("Deplacement simple");
                if(mHasEat == false)    // Première action
                {
                    mStack.push(vNextCase);
                    pCurrentCase.sCheckNE = false;
                    mListCurrentCase.set(mNbCurrentCase, pCurrentCase);
                }
            }
            else
            {
                if(pCurrentCase.sPiece.isEnnemie(vNextCase.getPiece()) == true)        // EDIT : Bon...
                {
                   ICase vNextCase2 = null; // On verifie 2 cases plus loin
                    if(vNextCase2.hasPiece() == false)              // On peut manger
                    {
                        // On ajoute à la pile et on réitère au NE à partir de la case libre jusqu'à ce qu'il n'y ait plus d'action possible
                        System.out.println("On peut manger ----------------------------------------------");
                        mStack.push(vNextCase);
                        mStack.push(vNextCase2);
                        mHasEat = true;
                        pCurrentCase.sCheckNE = true;
                        pCurrentCase.sCurrentCase = vNextCase2;
                        
                        pCurrentCase.sPiece = mPiece;   // TODO Change
                        mNbCurrentCase++;
                        mListCurrentCase.add(mNbCurrentCase, pCurrentCase);   
                       // this.savePath();
                    }
                }
            }
        }
    }
    /**
     * Pour Stocker les chemins possibles
     */
    private void savePath(){
        // On stocke le chemin
        // Si la pile actuelle a une taille plus grande que l'ancienne, meilleur chemin donc on remplace       
        if(mStack.size() > mTabPath[mNbPath].size())
            mTabPath[mNbPath] = mStack;
        else if(mStack.size() == mTabPath[mNbPath].size())  // Si égalité, on stocke 2 chemins
        {
            mNbPath++;
            mTabPath[mNbPath] = mStack;
        }
    }

    public ArrayList<ICase>  getCheminOffensif()
    {
        boolean start = true;
        //ICase de départ
        /*mBeginCase = new sCase();
        mBeginCase.sCheckNE = false;
        mBeginCase.sCurrentCase = this.getDepart();*/
        
        // Aère case
        sCase vCurrentCase = new sCase();
        vCurrentCase.sCurrentCase = mPiece.getCase();
        vCurrentCase.sPiece = mPiece;
        mNbPath = 0;
        
        mListCurrentCase.add(mNbCurrentCase, vCurrentCase);
        //mNbCurrentCase++;
        /* Tant qu'on a pas vérifié toutes les directions de la case de départ, on a pas toutes les possibilités */
        while (mNbCurrentCase != 0 || start != false)
        {
            start = false;
            // On vérifie les directions pour chaque case si ça n'a pas déjà été fait
            if(mListCurrentCase.get(mNbCurrentCase).sCheckNE == true)
                    this.checkNE(mListCurrentCase.get(mNbCurrentCase));
            else // Sinon on revient à la précédente 
              mNbCurrentCase--;
        }
        System.out.println("FIN ");
        return new ArrayList<ICase> ();
    }
}
